import { _decorator, Component, Node, Prefab, Sprite, Label, Button, Toggle, instantiate, resources, JsonAsset, sys, EditBox, Layout, error, UITransform, ScrollView } from 'cc';
const { ccclass, property } = _decorator;

import { Item } from './item/Item';//导入物品脚本
import { MessageBoxManager } from './MessageBoxManager';

@ccclass('BackpackManager')
export class BackpackManager extends Component {
    //消息框管理器
    @property(MessageBoxManager)
    messageBoxManager: MessageBoxManager = null;
    // 背包物品预制体
    @property({ type: Prefab })
    itemPrefab: Prefab = null;

    // 背包布局节点
    @property({ type: Node })
    layout: Node = null;

    // 物品详情框节点
    @property({ type: Node })
    itemDetailsBox: Node = null;

    // 背包容量显示标签
    @property({ type: Label })
    capacityDisplay: Label = null;

    //背包滚动视图
    @property(ScrollView)
    scrollView: ScrollView = null;

    // 全选按钮
    @property({ type: Button })
    selectAllButton: Button = null;

    // 使用按钮
    @property({ type: Button })
    useButton: Button = null;

    // 丢弃按钮
    @property({ type: Button })
    dropButton: Button = null;

    // 销毁按钮
    @property({ type: Button })
    destroyButton: Button = null;

    // 多选按钮
    @property({ type: Button })
    multiselectButton: Button = null;

    // 输入框
    @property({ type: EditBox })
    inputBox: EditBox = null;

    //背包关闭按钮
    @property({ type: Button })
    closeButton: Button = null;

    //被点击的物品和物品UI
    private clickedItem: Item = null;
    private clickitemPrefab: any = null;

    private isselectAll: boolean = false;

    //筛选按钮布局节点
    @property({ type: Layout })
    typeFilterLayout: Layout = null;

    // 背包物品数组
    backpackItems: Item[] = [];
    //背包已占容量
    backpackSize: number = 0;
    //背包最大容量
    maxBackpackSize: number = 10;

    // 加载背包数据
    loadBackpackData() {
        // 从本地存储中加载背包数据
        resources.load('jsons/beibaowupin', JsonAsset, (err, jsonAsset) => {
            if (err) {
                console.error(err);
                return;
            }
            const backpackData = jsonAsset.json;
            this.backpackSize = backpackData.items.length;
            this.maxBackpackSize = backpackData.backpack.maxCapacity;
            // 加载物品数据
            this.backpackItems = backpackData.items.map(itemData => {
                // 假设 itemData 包含 name, description, itemType, quantity 等属性
                return new Item(itemData.name, itemData.description, itemData.itemType, itemData.quantity);
            });
            this.updateUI();
        });
    }

    // 保存背包数据
    saveBackpackData() {
        const backpackData = {
            backpack: {
                currentCapacity: this.backpackSize,
                maxCapacity: this.maxBackpackSize
            },
            items: this.backpackItems
            // 只保存物品部分的数据
            // items: this.backpackItems.map(item => {
            //     return {
            //         name: item.name,
            //         quantity: item.quantity
            //     };
            // })
        };
        const jsonString = JSON.stringify(backpackData);
        sys.localStorage.setItem('backpackData', jsonString);
    }

    // 物品类型过滤器
    itemTypeFilters: { [key: string]: boolean } = { '全部': true, '武器': true, '装备': true, '药品': true, '材料': true, '道具': true };

    // 新增一个属性来跟踪是否有多选状态
    private isMultiselect: boolean = false;

    start() {

        // 初始化背包物品数组
        this.loadBackpackData();
        // 注册多选按钮的点击事件
        this.multiselectButton.node.on('click', this.onMultiselectButtonClicked, this);

        // 注册全选按钮的点击事件
        this.selectAllButton.node.on('click', this.onSelectAllButtonClicked, this);

        // 注册使用、丢弃、销毁按钮的点击事件
        this.useButton.node.on('click', this.onUseButtonClicked, this);
        this.dropButton.node.on('click', this.onDropButtonClicked, this);
        this.destroyButton.node.on('click', this.onDestroyButtonClicked, this);

        // 注册物品类型按钮的点击事件
        this.registerTypeButtonClickEvent('All', '全部');
        this.registerTypeButtonClickEvent('Weapon', '武器');
        this.registerTypeButtonClickEvent('Equipment', '装备');
        this.registerTypeButtonClickEvent('Potion', '药品');
        this.registerTypeButtonClickEvent('Material', '材料');
        this.registerTypeButtonClickEvent('Item', '道具');
        //注册背包关闭按钮的点击事件
        this.closeButton.node.on('click', this.onCloseButtonClicked, this);
    }

    // 注册背包关闭按钮的点击事件
    onCloseButtonClicked() {
        // 隐藏背包节点
        this.node.active = false;
        this.isMultiselect = false;
        this.isselectAll = false;
        this.selectAllButton.node.active = false;
        this.messageBoxManager.showMessage(0, '玩家关闭了背包');
    }
    /**
     * 添加物品到背包中。
     * 
     * @param item - 要添加的物品。
     */
    public addItem(item: Item) {
        // 检查背包中是否已经存在相同的物品
        const existingItem = this.backpackItems.find(i => i.id === item.id);
        //如果背包物品数量大于背包最大容量
        if (this.backpackSize === this.maxBackpackSize) {
            this.messageBoxManager.showMessage(2, '太多了，已经装不下了');
            return
        }
        if (existingItem) {
            // 如果存在相同的物品，增加其数量
            existingItem.quantity += item.quantity;

        } else {
            // 如果不存在相同的物品，将物品添加到背包物品数组中
            this.backpackItems.push(item);
        }
        //更新背包UI界面
        this.updateUI();
    }
    public removeItem(item: Item) {
        const index = this.backpackItems.findIndex(i => i.name === item.name);
        if (index !== -1) {
            this.backpackItems.splice(index, 1);
        }
    }

    findItem(name: string): Item | undefined {
        return this.backpackItems.find(i => i.name === name);
    }

    registerTypeButtonClickEvent(buttonName: string, type: string) {
        const button = this.typeFilterLayout.node.getChildByName(buttonName).getComponent(Button);
        button.node.on('click', () => {
            //如果背包没有物品，则不执行任何操作
            if (this.backpackItems.length === 0) {
                return;
            }
            // 切换物品类型过滤器
            this.itemTypeFilters = { '全部': false, '武器': false, '装备': false, '药品': false, '材料': false, '道具': false };

            if (type === '全部') {
                this.itemTypeFilters = { '全部': true, '武器': true, '装备': true, '药品': true, '材料': true, '道具': true };
            } else {
                this.itemTypeFilters[type] = true;
            }
            this.updateUI();
        }, this);
    }

    onMultiselectButtonClicked() {

        //如果背包没有物品，则不执行任何操作
        if (this.backpackItems.length === 0) {
            return;
        }
        // 切换多选状态
        this.isMultiselect = !this.isMultiselect;

        // 根据多选状态显示或隐藏全选按钮和物品复选框
        this.selectAllButton.node.active = this.isMultiselect;
        this.layout.children.forEach(child => {
            child.getChildByName('Checkbox').active = this.isMultiselect;
        });

        // 如果进入多选状态，取消所有物品的选中状态
        if (this.isMultiselect) {
            this.layout.children.forEach(child => {
                const checkbox = child.getChildByName('Checkbox').getComponent(Toggle);
                this.isselectAll = false;
                checkbox.isChecked = this.isselectAll;
            });
        }
    }

    onSelectAllButtonClicked() {

        //如果背包没有物品，则不执行任何操作
        if (this.backpackItems.length === 0) {
            return;
        }



        let selectItem: string[] = [];
        this.isselectAll = !this.isselectAll;
        // 遍历背包中的所有物品
        this.layout.children.forEach(child => {
            // 获取每个物品的复选框组件
            const checkbox = child.getChildByName('Checkbox').getComponent(Toggle);
            // 设置复选框的选中状态为全选按钮的状态

            checkbox.isChecked = !checkbox.isChecked;
            //为选中的物品显示操作按钮
            if (checkbox.isChecked) {
                selectItem.push(child.name);
                this.updateItemDetails(this.backpackItems.find(i => i.id === selectItem[selectItem.length - 1]));
            }
        });
        if(selectItem.length===0)this.updateItemDetails(null);
    }

    onUseButtonClicked() {

        //如果背包没有物品，则不执行任何操作
        if (this.backpackItems.length === 0) {
            return;
        }
        this.executeBatchOperation('use');
    }

    onDropButtonClicked() {

        //如果背包没有物品，则不执行任何操作
        if (this.backpackItems.length === 0) {
            return;
        }
        this.executeBatchOperation('drop');
    }

    onDestroyButtonClicked() {

        //如果背包没有物品，则不执行任何操作
        if (this.backpackItems.length === 0) {
            return;
        }
        this.executeBatchOperation('destroy');
    }

    executeBatchOperation(operation: string) {
        if (this.isMultiselect) {
            // 获取所有选中的物品
            const selectedItems = this.layout.children.filter(child => {
                const checkbox = child.getChildByName('Checkbox').getComponent(Toggle);
                return checkbox.isChecked;
            });

            // 对选中的物品和物品UI执行对应的操作
            selectedItems.forEach(item => {
                const backpackItem = this.backpackItems.find(i => i.id === item.name);
                if (backpackItem) {
                    this.executeSingleOperation(operation, backpackItem, item);
                }
            });

            // 退出多选状态
            this.isMultiselect = false;
            this.selectAllButton.node.active = false;
            this.layout.children.forEach(child => {
                child.getChildByName('Checkbox').active = false;
            });
        } else {

            // 执行单个物品的操作
            this.executeSingleOperation(operation, this.clickedItem, this.clickitemPrefab);
        }
    }

    executeSingleOperation(operation: string, item: Item = null, itemPrefab: any) {
        // 获取输入框中的值
        const inputValue = parseInt(this.inputBox.string, 10);
        // 如果输入值无效，则不执行任何操作
        if (isNaN(inputValue) || inputValue <= 0) {
            switch (operation) {
                case 'use':
                    // 实现单个物品使用的逻辑
                    this.useItem(item, itemPrefab, 1);
                    break;
                case 'drop':
                    // 实现单个物品丢弃的逻辑
                    this.dropItem(item, itemPrefab, 1);
                    break;
                case 'destroy':
                    // 实现单个物品销毁的逻辑
                    this.destroyItem(item, itemPrefab, 1);
                    break;
                default:
                    break;
            }
        } else {
            switch (operation) {
                case 'use':
                    // 实现单个物品使用的逻辑
                    this.useItem(item, itemPrefab, inputValue);
                    break;
                case 'drop':
                    // 实现单个物品丢弃的逻辑
                    this.dropItem(item, itemPrefab, inputValue);
                    break;
                case 'destroy':
                    // 实现单个物品销毁的逻辑
                    this.destroyItem(item, itemPrefab, inputValue);
                    break;
                default:
                    break;
            }
        }



        // 根据操作类型执行对应的单个物品操作

    }
    useItem(item: Item, itemPrefab: any, quantity: number) {

        // 获取物品数据
        // 如果输入的数量大于等于物品剩余的数量，则使用全部物品
        if (quantity >= item.quantity) {
            quantity = item.quantity;
        }

        // 更新物品数量
        item.quantity -= quantity;

        // 更新物品显示
        const nameLabel = itemPrefab.getChildByName('Name').getComponent(Label);
        nameLabel.string = item.name + ' x' + item.quantity;

        // 更新背包中的物品数量
        const backpackItem = this.backpackItems.find(i => i.name === item.name);
        if (backpackItem) {
            backpackItem.quantity = item.quantity;
            this.messageBoxManager.showMessage(0, '你使用了' + `<b><color=${'#BD680D'}>${quantity}</color>` + ' * ' + item.name);
        }

        // 如果物品数量为0，则从背包中移除该物品
        if (item.quantity <= 0) {
            this.messageBoxManager.showMessage(2, '已耗尽所有的' + item.name);
            this.backpackItems = this.backpackItems.filter(i => i !== item);
            itemPrefab.destroy();
            // 更新物品详情框为空
            this.updateItemDetails(null);
        }

        // 更新背包容量显示
        this.updateCapacityDisplay();
    }

    dropItem(item: Item, itemPrefab: any, quantity: number) {

        // 如果输入的数量大于等于物品剩余的数量，则丢弃全部物品
        if (quantity >= item.quantity) {
            quantity = item.quantity;
        }

        // 更新物品数量
        item.quantity -= quantity;

        // 更新物品显示
        const nameLabel = itemPrefab.getChildByName('Name').getComponent(Label);
        nameLabel.string = item.name + ' x' + item.quantity;

        // 更新背包中的物品数量
        const backpackItem = this.backpackItems.find(i => i.name === item.name);
        if (backpackItem) {
            backpackItem.quantity = item.quantity;
            this.messageBoxManager.showMessage(0, '你丢掉了' + `<b><color=${'#BD680D'}>${quantity}</color>` + ' * ' + item.name);
        }

        // 如果物品数量为0，则从背包中移除该物品
        if (item.quantity <= 0) {
            this.messageBoxManager.showMessage(2, '已耗尽所有的' + item.name);
            this.backpackItems = this.backpackItems.filter(i => i !== item);
            itemPrefab.destroy();
            // 更新物品详情框为空
            this.updateItemDetails(null);
        }

        // 更新背包容量显示
        this.updateCapacityDisplay();
    }

    destroyItem(item: Item, itemPrefab: any, quantity: number) {

        // 如果输入的数量大于等于物品剩余的数量，则销毁全部物品
        if (quantity >= item.quantity) {
            quantity = item.quantity;
        }

        // 更新物品数量
        item.quantity -= quantity;

        // 更新物品UI
        const nameLabel = itemPrefab.getChildByName('Name').getComponent(Label);
        nameLabel.string = item.name + ' x' + item.quantity;

        // 更新背包中的物品数量
        const backpackItem = this.backpackItems.find(i => i.name === item.name);
        if (backpackItem) {
            backpackItem.quantity = item.quantity;
            this.messageBoxManager.showMessage(0, '你销毁了' + `<b><color=${'#BD680D'}>${quantity}</color>` + item.name);
        }

        // 如果物品数量为0，则从背包中移除该物品
        if (item.quantity <= 0) {
            this.messageBoxManager.showMessage(2, '已耗尽所有的' + item.name);
            this.backpackItems = this.backpackItems.filter(i => i !== item);
            itemPrefab.destroy();
            // 更新物品详情框为空
            this.updateItemDetails(null);
        }

        // 更新背包容量显示
        this.updateCapacityDisplay();
    }
    /**
     * 更新背包界面，显示背包中的物品。
     * 根据当前的物品类型过滤器，只显示符合条件的物品。
     * 如果处于多选状态，还会显示物品的复选框。
     */
    updateUI() {
        this.scrollView.scrollToTop();
        //动态增加背包容器UI高度,一行物品增加40
        const itemLine = this.backpackItems.length / 2;
        this.layout.getComponent(UITransform).height = (itemLine * 40) - 20;
        // 清除布局中的所有子节点，即清除之前显示的所有物品
        this.layout.children.forEach(child => child.destroy());

        // 遍历背包中的所有物品
        for (let item of this.backpackItems) {
            // 检查当前物品的类型是否符合过滤器设置，或者是否设置为显示所有类型
            if (this.itemTypeFilters[item.itemType] || this.itemTypeFilters.all) {
                // 实例化物品UI节点预制体
                const itemPrefab = instantiate(this.itemPrefab);
                // 获取物品预制体中的名称标签组件
                const nameLabel = itemPrefab.getChildByName('Name').getComponent(Label);
                // 设置名称标签的文本为物品名称和数量
                nameLabel.string = item.name + ' x' + item.quantity;
                //把物品ID作为物品UI节点的名称
                itemPrefab.name = item.id;
                // 设置物品预制体的点击事件，点击时调用 onItemClicked 方法并传递当前物品作为参数
                itemPrefab.on('click', this.onItemClicked.bind(this, item, itemPrefab));
                // 如果处于多选状态，显示物品的复选框
                itemPrefab.getChildByName('Checkbox').active = this.isMultiselect;
                // 将物品预制体添加到布局中
                this.layout.addChild(itemPrefab);
            }
        }

        // 更新物品详情框为空
        this.updateItemDetails(null);
        // 更新背包容量显示
        this.updateCapacityDisplay();
    }

    onItemClicked(item: Item, itemPrefab: any) {
        if (this.isMultiselect) {
            itemPrefab.getChildByName("Checkbox").getComponent(Toggle).isChecked = !itemPrefab.getChildByName("Checkbox").getComponent(Toggle).isChecked;
        }

        this.updateItemDetails(item);
        // 记录被点击的物品
        this.clickedItem = item;
        this.clickitemPrefab = itemPrefab;

        // if (item.function) {
        //     this.useButton.enabled = true;
        // } else {
        //     this.useButton.enabled = false;
        // }
    }

    updateItemDetails(item: Item) {
        if (item) {
            this.itemDetailsBox.getChildByName("操作按钮").active = true;
            // 更新物品详情框显示
            this.itemDetailsBox.getChildByName("Layout").getChildByName("名称").getComponent(Label).string = item.name;
            this.itemDetailsBox.getChildByName("Layout").getChildByName("描述").getComponent(Label).string = item.description;
        } else {
            this.itemDetailsBox.getChildByName("操作按钮").active = false;
            // 清空物品详情框显示
            this.itemDetailsBox.getChildByName("Layout").getChildByName("名称").getComponent(Label).string = '';
            this.itemDetailsBox.getChildByName("Layout").getChildByName("描述").getComponent(Label).string = '';
        }
    }

    updateCapacityDisplay() {
        this.capacityDisplay.string = `背包容量: ${this.backpackItems.length}/${this.maxBackpackSize}`;
    }
}
